home *** CD-ROM | disk | FTP | other *** search
/ JCSM Shareware Collection 1993 November / JCSM Shareware Collection - 1993-11.iso / cl720 / sst115j.lzh / SSTSTR.C < prev    next >
C/C++ Source or Header  |  1992-03-23  |  21KB  |  761 lines
  1. /* ------------------------------------------------------------------------ */
  2. /*                                 sststr.c                                 */
  3. /*                                                                          */
  4. /*                        string handling functions                         */
  5. /*                                                                          */
  6. /*       CopyRight (C) 1991,1992  Steven Lutrov.  All rights reserved.      */
  7. /* ------------------------------------------------------------------------ */
  8.  
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <ctype.h>
  12. #include <alloc.h>
  13.  
  14. #include "sststr.h"
  15.  
  16.  
  17. /* ------------------------------------------------------------------------ */
  18. /*                         local function prototypes                        */
  19. /* ------------------------------------------------------------------------ */
  20.  
  21. char  to_lower       (char c);
  22. char  to_upper       (char c);
  23. char  to_nocr        (char c);
  24. int   is_alpha       (char c);
  25. int   is_punct       (char c);
  26. int   is_space       (char c);
  27. int   is_num         (char c);
  28.  
  29.  
  30. /* ------------------------------------------------------------------------ */
  31. /*                converts a long to a string with comma spacing            */
  32. /* ------------------------------------------------------------------------ */
  33. char *strcomma(long n)
  34. {
  35.     static char buf2[15];
  36.     char buf1[15];
  37.     register int p1,p2;
  38.     int positions = 0;
  39.  
  40.     memset(buf1,0,15);
  41.     memset(buf2,0,15);
  42.     sprintf(buf1,"%ld",n);
  43.     p1 = strlen(buf1);
  44.     p2 = (p1 > 9) ? p1 + 3 : (p1 > 6) ? p1 + 2 : (p1 > 3) ? p1 + 1 : p1;
  45.     p1--;
  46.     p2--;
  47.     while (p1 >= 0) {
  48.         buf2[p2--] = buf1[p1--];
  49.         if (++positions % 3 == 0)
  50.             buf2[p2--] = ',';
  51.     }
  52.     return buf2;
  53. }
  54.  
  55.  
  56.  
  57. /* ------------------------------------------------------------------------ */
  58. /*                   deletes a substring from a string                      */
  59. /* ------------------------------------------------------------------------ */
  60. char *strdelete (char *a,  char *s)
  61.  
  62. {
  63.    register char *p, *q;
  64.  
  65.    q = strinc(a, s);
  66.    if(!q)
  67.       return(NULL);
  68.    p = q + strlen(a);
  69.    strcpy(q, p);
  70.    return(s);
  71. }
  72.  
  73. /* ------------------------------------------------------------------------ */
  74. /*     change all occurances of a case independant substring in a string    */
  75. /* ------------------------------------------------------------------------ */
  76. char *strichangestr (char *s,  char *a,  char *b)
  77.  
  78. {
  79.     register int n=0;
  80.     register char *p = s;
  81.     int    i;
  82.  
  83.    i = strlen(b);
  84.    for(;;)  {
  85.      if(strisrep(p, a, b) == NULL)
  86.      break;
  87.      p += i;
  88.      n++;
  89.    }
  90.    return(n ? s: NULL);
  91. }
  92.  
  93. /* ------------------------------------------------------------------------ */
  94. /*         return number occurances of a substring found in a string        */
  95. /* ------------------------------------------------------------------------ */
  96. int stricountstr (char *a,  char *s)
  97.  
  98. {
  99.    register char *p = s;
  100.    register int n = 0;
  101.    int l;
  102.  
  103.    l = strlen(a);
  104.    p = striinc(a, p);
  105.    while(p != NULL)  {
  106.       n++;
  107.       p += l;
  108.       p = striinc(a, p);
  109.    }
  110.    return(n);
  111. }
  112.  
  113. /* ------------------------------------------------------------------------ */
  114. /*      search and replace a case independant substring in a string         */
  115. /* ------------------------------------------------------------------------ */
  116. char *strisrep (char *s,  char *a,  char *b)
  117.  
  118. {
  119.     register char *p;
  120.     register int d;
  121.  
  122.    if((p = striinc(a, s)) != NULL) {
  123.       stridelete(a, s);
  124.       d = p - s;
  125.       strinsert(b, s, d);
  126.       p = s;
  127.    }
  128.    return(p);
  129. }
  130.  
  131. /* ------------------------------------------------------------------------ */
  132. /*                           left justify a string                          */
  133. /* ------------------------------------------------------------------------ */
  134. char *strljust (char *s)
  135.  
  136. {
  137.    register char *p = s;
  138.    register char *q;
  139.  
  140.    for(q = s; isspace(*q) && (*q != EOS); q++);
  141.    if(p != q)
  142.       while(*q != EOS) {
  143.      *p++ = *q;
  144.      *q++ = ' ';
  145.       }
  146.    return(s);
  147. }
  148.  
  149. /* ------------------------------------------------------------------------ */
  150. /*                 trims the leading spaces of a string                     */
  151. /* ------------------------------------------------------------------------ */
  152. char *strltrim (char *s)
  153.  
  154. {
  155.    register char *p;
  156.    register char *q;
  157.  
  158.    p = q = s;
  159.    while(isspace(*p))
  160.       p++;
  161.    while(*p != EOS)
  162.       *q++ = *p++;
  163.    *q = EOS;
  164.    return(s);
  165. }
  166.  
  167. /* ------------------------------------------------------------------------ */
  168. /*                    copy a substring into a new string                    */
  169. /* ------------------------------------------------------------------------ */
  170. char *strmiddle (char *s,  int p,  int l)
  171.  
  172. {
  173.     register int i;
  174.     char  *r;
  175.  
  176.    if((r = malloc(l + 1)) != NULL) {
  177.        for(i = 0; i < l; i++)
  178.      *(r + i) = *(s + p + i);
  179.       *(r + l) = EOS;
  180.    }
  181.    return(r);
  182. }
  183.  
  184. /* ------------------------------------------------------------------------ */
  185. /*                   count occurances of a char in a string                 */
  186. /* ------------------------------------------------------------------------ */
  187. int strcountchar (char *s,  int c)
  188.  
  189. {
  190.     register int n = 0;
  191.     register char *p;
  192.  
  193.    for(p = s; (*p != EOS); p++)
  194.       if(c == *p)
  195.          n++;
  196.    return(n);
  197. }
  198.  
  199. /* ------------------------------------------------------------------------ */
  200. /*                           right justify a string                         */
  201. /* ------------------------------------------------------------------------ */
  202. char *strrjust (char *s)
  203.  
  204. {
  205.    register char *p, *q;
  206.  
  207.    for(p = s; (*p != EOS); p++);           /* find end of string */
  208.    p--;
  209.    for(q = p; isspace(*q) && q >= s; q--); /* find last non-space char */
  210.    if(p != q)   {
  211.       while(q >= s)  {
  212.      *p-- = *q;
  213.      *q-- = ' ';
  214.       }
  215.    }
  216.    return(s);
  217. }
  218.  
  219. /* ------------------------------------------------------------------------ */
  220. /*                             rotate a string left                         */
  221. /* ------------------------------------------------------------------------ */
  222. char *strrotleft (char *s,  int n)
  223.  
  224. {
  225.     register int i, j;
  226.     char  t;
  227.  
  228.    if(EOS != *s)
  229.       for(j = 0; j < n; j++) {
  230.      t = *(s);
  231.          for(i = 0; *(s + i); i++)
  232.             *(s + i) = *(s + i + 1);
  233.          *(s + i - 1) = t;
  234.       }
  235.    return(s);
  236. }
  237.  
  238. /* ------------------------------------------------------------------------ */
  239. /*                            rotate a string right                         */
  240. /* ------------------------------------------------------------------------ */
  241. char *strrotright (char *s,  int n)
  242. {
  243.     register int i, j;
  244.     int  l;
  245.     char t;
  246.  
  247.    if(EOS != *s) {
  248.       l = strlen(s) - 1;
  249.       for(j = 0; j < n; j++)  {
  250.      t = *(s + l);
  251.      for(i = l; i > 0; i--)
  252.         *(s + i) = *(s + i - 1);
  253.      *s = t;
  254.       }
  255.    }
  256.    return(s);
  257. }
  258.  
  259. /* ------------------------------------------------------------------------ */
  260. /*                   change all occurances of a sunstring                   */
  261. /* ------------------------------------------------------------------------ */
  262. char *strchangestr (char *s,  char *a,  char *b)
  263.  
  264. {
  265.     register int n = 0;
  266.     register char *p = s;
  267.     int    i;
  268.  
  269.    i = strlen(b);
  270.    for(;;)  {
  271.    if(strsrep(p, a, b) == NULL)
  272.      break;
  273.       p += i;
  274.       n++;
  275.    }
  276.    return(n ? s : NULL);
  277. }
  278.  
  279.  
  280. /* ------------------------------------------------------------------------ */
  281. /*                      modify the length of a string                       */
  282. /* ------------------------------------------------------------------------ */
  283. char *strresize (char *s,  int n)
  284.  
  285. {
  286.     register int i;
  287.     register int l;
  288.  
  289.    l = strlen(s);
  290.    if(n < l)
  291.       *(s + n) = EOS;
  292.    else   {
  293.     for(i = l; i <n; i++)
  294.      *(s + i) = ' ';
  295.       *(s + i) = EOS;
  296.    }
  297.    return(s);
  298. }
  299.  
  300.  
  301. /* ------------------------------------------------------------------------ */
  302. /*                            shift a string left                           */
  303. /* ------------------------------------------------------------------------ */
  304. char *strshiftleft (char *s,  int n)
  305.  
  306. {
  307.    register int i;
  308.    int    j;
  309.  
  310.    if(EOS != *s)
  311.       for(j = 0; j < n; j++)  {
  312.      for(i = 0; *(s + i); i++)
  313.         *(s + i) = *(s + i + 1);
  314.      *(s + i - 1) = ' ';
  315.       }
  316.    return(s);
  317. }
  318.  
  319.  
  320. /* ------------------------------------------------------------------------ */
  321. /*                           shift a string right                           */
  322. /* ------------------------------------------------------------------------ */
  323. char *strshiftright (char *s,  int n)
  324.  
  325. {
  326.    register int i;
  327.    int j, l;
  328.  
  329.    if(EOS != *s) {
  330.      l = strlen(s) - 1;
  331.       for(j = 0; j < n; j++) {
  332.     for(i = l; i > 0; i--)
  333.             *(s + i) = *(s  + i - 1);
  334.          *s = ' ';
  335.       }
  336.    }
  337.    return(s);
  338. }
  339.  
  340. /* ------------------------------------------------------------------------ */
  341. /*                count occurances of a substring in a string               */
  342. /* ------------------------------------------------------------------------ */
  343. int strcountstr (char *a,  char *s)
  344.  
  345. {
  346.     register char *p;
  347.     register int n = 0;
  348.     int l;
  349.  
  350.    l = strlen(a);
  351.    p = strinc(a, s);
  352.    while(p != NULL) {
  353.       n++;
  354.       p += l;
  355.       p = strinc(a, p);
  356.    }
  357.    return(n);
  358. }
  359.  
  360. /* ------------------------------------------------------------------------ */
  361. /*                 search for and replace a sunbstring in a string          */
  362. /* ------------------------------------------------------------------------ */
  363. char *strsrep (char *s,  char *a,  char *b)
  364.  
  365. {
  366.    register char *p;
  367.    register int d;
  368.  
  369.    if((p = strinc(a, s)) != NULL) {
  370.       strdelete(a, s);
  371.       d = p - s;
  372.       strinsert(b, s, d);
  373.       p = s;
  374.    }
  375.    return(p);
  376. }
  377.  
  378. /* ------------------------------------------------------------------------ */
  379. /*                        trim string of trailing blanks                    */
  380. /* ------------------------------------------------------------------------ */
  381. char *strtrim (char *s)
  382.  
  383. {
  384.    register int i;
  385.  
  386.    for(i = strlen(s) - 1; isspace(s[i]) && i >= 0; i--);
  387.    s[i+1] = EOS;
  388.    return(s);
  389. }
  390.  
  391. /* ------------------------------------------------------------------------ */
  392. /*                     convert a string to initial capitals                 */
  393. /* ------------------------------------------------------------------------ */
  394. char *struplow (char *s)
  395.  
  396. {
  397.    register int i;
  398.  
  399.    for(i = 0; *(s + i); i++)
  400.       *(s + i) = touplow(s, s + i,*(s + i));
  401.    return(s);
  402. }
  403.  
  404. /* ------------------------------------------------------------------------ */
  405. /*                     return non-zero if a string is blank                 */
  406. /* ------------------------------------------------------------------------ */
  407. int strisblank(char  *s)
  408. {
  409.    register char *p = s;
  410.  
  411.    for(p = s; (*p != EOS); p++)
  412.       if(!isspace(*p))
  413.          return(0);
  414.    return(1);
  415. }
  416.  
  417.  
  418. /* ------------------------------------------------------------------------ */
  419. /*                   change all matching chars in a string                  */
  420. /* ------------------------------------------------------------------------ */
  421. int strchangechar(char *s,  int a, int b)
  422.  
  423. {
  424.     register int  n = 0;
  425.     register char  *p;
  426.  
  427.    for(p = s; (*p != EOS); p++)
  428.       if(a == *p)  {
  429.      *p = b;
  430.      n++;
  431.       }
  432.    return(n);
  433. }
  434.  
  435. /* ------------------------------------------------------------------------ */
  436. /*                      returns the check-sum of a string                   */
  437. /* ------------------------------------------------------------------------ */
  438. unsigned long strchecksum(char *s)
  439.  
  440. {
  441.     register char *p;
  442.     unsigned long c = 0L;
  443.  
  444.    for(p = s; (*p != EOS); p++)
  445.       c += ((unsigned long)*p);
  446.    return(c);
  447. }
  448.  
  449.  
  450. /* ------------------------------------------------------------------------ */
  451. /*                            encode/decode a string                        */
  452. /* ------------------------------------------------------------------------ */
  453. char *strcode (char *s,  char *k)
  454.  
  455. {
  456.     register char *q = k;
  457.     register char *p;
  458.  
  459.    for(p = s; (*p != EOS); p++)
  460.    {  if(*p != *q)
  461.          *p = *p^*q;
  462.       q++;
  463.       if(*q == EOS)
  464.          q = k;
  465.    }
  466.    return(s);
  467. }
  468.  
  469. /* ------------------------------------------------------------------------ */
  470. /*               delete all occurances of a substring in a string           */
  471. /* ------------------------------------------------------------------------ */
  472. char *strdeleteall (char *a, char *s)
  473.  
  474. {
  475.     register int n = 0;
  476.     register char *p = s;
  477.  
  478.    while(NULL != (p = strinc(a, p)))
  479.    {  strdelete(a, p);
  480.       n++;
  481.    }
  482.    return(n ? s : NULL);
  483. }
  484.  
  485. /* ------------------------------------------------------------------------ */
  486. /*          change all matching case-independant chars in a string          */
  487. /* ------------------------------------------------------------------------ */
  488. int strichange(char *s, int a, int b)
  489.  
  490. {
  491.     register int n = 0;
  492.     register char *p;
  493.  
  494.    a = toupper(a);
  495.    for(p = s; (*p != EOS);p++ )
  496.       if(a == toupper(*p)) {
  497.      *p = b;
  498.      n++;
  499.       }
  500.    return(n);
  501. }
  502.  
  503. /* ------------------------------------------------------------------------ */
  504. /*              returns the checksum of a case independant string           */
  505. /* ------------------------------------------------------------------------ */
  506. unsigned long strichecksum (char *s)
  507.  
  508. {
  509.    register char *p;
  510.    unsigned long c = 0L;
  511.  
  512.    for(p = s; (*p != EOS); p++)
  513.       c += ((unsigned long)toupper(*p));
  514.    return(c);
  515. }
  516.  
  517. /* ------------------------------------------------------------------------ */
  518. /*             delete a case independant sunstring from a string            */
  519. /* ------------------------------------------------------------------------ */
  520. char *stridelete (char *a,  char *s)
  521.  
  522. {
  523.    register char *p, *q;
  524.  
  525.    if(NULL == (q = striinc(a, s)))
  526.       return(NULL);
  527.    p = q + strlen(a);
  528.    strcpy(q, p);
  529.    return(s);
  530. }
  531.  
  532. /* ------------------------------------------------------------------------ */
  533. /*    delete all occurances of a case independant substring from a string   */
  534. /* ------------------------------------------------------------------------ */
  535. char *strideleteall (char *a, char *s)
  536.  
  537. {
  538.     register int n = 0;
  539.     register char *p = s;
  540.  
  541.    while(NULL != (p = striinc(a, p))) {
  542.       stridelete(a, p);
  543.       n++;
  544.    }
  545.    return(n ? s : NULL);
  546. }
  547.  
  548. /* ------------------------------------------------------------------------ */
  549. /*                test for inclusion of a case independant string           */
  550. /* ------------------------------------------------------------------------ */
  551. char *striinc (char *a,  char *s)
  552.  
  553. {
  554.    register int m;
  555.    register char *p;
  556.  
  557.    m = strlen(a);
  558.    for(p = s; (*p != EOS); p++)
  559.       if(!strnicmp(a, p, m))
  560.          return(p);
  561.    return(NULL);
  562. }
  563.  
  564. /* ------------------------------------------------------------------------ */
  565. /*                      test for inclusion of a substring                   */
  566. /* ------------------------------------------------------------------------ */
  567. char *strinc (char *a,  char *s)
  568.  
  569. {
  570.     register int m;
  571.     register char *p;
  572.  
  573.    m = strlen(a);
  574.    for(p = s; (*p != EOS); p++)
  575.       if(!strncmp(a, p, m))
  576.          return(p);
  577.    return(NULL);
  578. }
  579.  
  580. /* ------------------------------------------------------------------------ */
  581. /*                        insert one string into another                    */
  582. /* ------------------------------------------------------------------------ */
  583. char *strinsert (char *a,  char *s,  int p)
  584.  
  585. {
  586.    register int i, l;
  587.  
  588.    l = strlen(a);
  589.    for(i = strlen(s); i >= p; i--)
  590.       *(s + l + i) = *(s + i);
  591.    for(i = 0; i < l; i++)
  592.       *(s + p + i) = *(a + i);
  593.    return(s);
  594. }
  595.  
  596. /* ------------------------------------------------------------------------ */
  597. /*          count occurances of a case independant char in a string         */
  598. /* ------------------------------------------------------------------------ */
  599. int stricountchar (char *s, int c)
  600.  
  601. {
  602.     register int n = 0;
  603.     register char *p;
  604.  
  605.    c = toupper(c);
  606.    for(p = s; (*p != EOS); p++)
  607.       if(c == toupper(*p))
  608.          n++;
  609.    return(n);
  610. }
  611.  
  612. /* ------------------------------------------------------------------------ */
  613. /*       convert a char to the opposite case of its predecessing char       */
  614. /* ------------------------------------------------------------------------ */
  615. int touplow(char *s, char *p, int c)
  616.  
  617. {
  618.    if(strchr(" -_,./", *(p - 1)) || (p == s))
  619.       return(toupper(c));
  620.    return(tolower(c));
  621. }
  622.  
  623.  
  624.  
  625. /* ------------------------------------------------------------------------ */
  626. /*   the source string is copied to the destination string with character   */
  627. /*            conversions as specified in the (option) parameter.           */
  628. /* ------------------------------------------------------------------------ */
  629. char *strcvt(char *d, char *s, int option, int ml)
  630.  
  631. {
  632.     int bdest,ctr,nbctr,skipc;
  633.     char *savdest,*smaxout,pch;
  634.  
  635.     if(!d || !s || !ml)
  636.         return((char *)0);
  637.     smaxout = s +strlen(s);
  638.     if(option&NOTRAILBLANKS)
  639.         for(--smaxout;*smaxout==' '&&smaxout >= s;--smaxout)
  640.             ;
  641.     for(pch='\0',savdest=d,bdest=skipc=nbctr= ctr=0;
  642.         s <=smaxout&&ml && *s; ++ctr, ++s, skipc=bdest = 0) {
  643.         if(*s!=' ')
  644.             ++nbctr;
  645.         if(option & NOBLANKS && *s == ' ')
  646.             continue;
  647.         if(option & NONONALPHA && (!is_alpha (*s) &&  !is_space(*s)))
  648.             continue;
  649.         if(option & NONONNUMERIC && ! is_num(*s))
  650.             continue;
  651.         if(option & NOLEADBLANKS && !nbctr) {
  652.             pch = ' ';
  653.             continue;
  654.         }
  655.         if(option & NOALPHA && is_alpha(*s))
  656.             continue;
  657.         if(option & NONUMERIC && is_num(*s))
  658.             continue;
  659.         if(option & NOPUNCT && is_punct(*s))
  660.             continue;
  661.         if(option & TOSINGLE && (*s == ' ' && pch==' '))
  662.             continue;
  663.         if(option & TOUPPER) {
  664.             *d= to_upper(*s);
  665.             skipc = bdest = 1;
  666.         }
  667.         if(option & TOLOWER) {
  668.             *d = to_lower(*s);
  669.             skipc = bdest = 1;
  670.         }
  671.         if(option & TONOCR) {
  672.             *d = to_nocr(*s);
  673.             skipc = bdest = 1;
  674.         }
  675.         if(option & TOPROPER && (pch == ' ' || pch == ',' ||
  676.            pch == '.' || pch == '\0')) {
  677.             *d = to_upper(*s);
  678.             skipc = bdest = 1;
  679.         }
  680.         if(option & TOUNPROPER && (pch==' ' || pch==','||
  681.            pch == '.' || pch == '\0')) {
  682.             *d = to_lower(*s);
  683.             skipc = bdest = 1;
  684.         }
  685.         if(!skipc) {
  686.             *d++ = *s;    /* default case, copy */
  687.             pch = *s;
  688.             --ml;        /* character and decrement */
  689.         } else if(bdest) {
  690.             pch = *d;
  691.             ++d;
  692.             --ml;
  693.         }
  694.     }
  695.     *d='\0';
  696.     return(savdest);
  697. }
  698.  
  699. /* ------------------------------------------------------------------------ */
  700. /*     translate an upper case character to it's lower case equivalent      */
  701. /* ------------------------------------------------------------------------ */
  702. char to_lower(char c)
  703.  
  704. {
  705.     return((char)((c>='A' && c<='Z') ? (char)(c+' ') : c));
  706. }
  707.  
  708. /* ------------------------------------------------------------------------ */
  709. /*                  translate an control character to a space               */
  710. /* ------------------------------------------------------------------------ */
  711. char to_nocr(char c)
  712.  
  713. {
  714.     return((char) ( (c=='\n') ? (' ') : c));
  715. }
  716.  
  717. /* ------------------------------------------------------------------------ */
  718. /*        translate a lower case character to it's upper case equivalent    */
  719. /* ------------------------------------------------------------------------ */
  720. char to_upper(char c)
  721. {
  722.     return((char) ( (c >= 'a' && c <= 'z') ? (char)(c-' '):c) );
  723. }
  724.  
  725. /* ------------------------------------------------------------------------ */
  726. /*                 test if character is an alpha character                  */
  727. /* ------------------------------------------------------------------------ */
  728. int is_alpha(char c)
  729.  
  730. {
  731.     return(((c>='a'&&c<='z')||(c>='A'&&c<='Z')) ? 1 : 0);
  732. }
  733.  
  734.  
  735. /* ------------------------------------------------------------------------ */
  736. /*               test if character is a punctuation character               */
  737. /* ------------------------------------------------------------------------ */
  738. int is_punct(char c)
  739. {
  740.     return((c=='.'||c==','||c=='!'||c==';'||c==':'||c=='\''||c=='"'||
  741.         c=='?') ? 1 : 0);
  742. }
  743.  
  744. /* ------------------------------------------------------------------------ */
  745. /*                  test if character is a space character.                 */
  746. /* ------------------------------------------------------------------------ */
  747. int is_space(char c)
  748. {
  749.     return((c==' ') ? 1 : 0);
  750. }
  751.  
  752. /* ------------------------------------------------------------------------ */
  753. /*                        test if character is a numeric.                   */
  754. /* ------------------------------------------------------------------------ */
  755. int is_num(char c)
  756. {
  757.     return((c>='0'&&c<='9') ? 1 : 0);
  758. }
  759.  
  760.  
  761.